/*! Magnific Popup - v0.9.9 - 2013-12-27
 * http://dimsemenov.com/plugins/magnific-popup/
 * Copyright (c) 2013 Dmitry Semenov; */
/*
 * Nuxeo WARN: This script has been patched for:
 *   - https://jira.nuxeo.com/browse/NXP-14061
 *
 * Please re-apply any patch when upgrading this script.
 */

;
(function($) {

  /* >>core */
  /**
   *
   * Magnific Popup Core JS file
   *
   */

  /**
   * Private static constants
   */
  var CLOSE_EVENT = 'Close', BEFORE_CLOSE_EVENT = 'BeforeClose', AFTER_CLOSE_EVENT = 'AfterClose', BEFORE_APPEND_EVENT = 'BeforeAppend', MARKUP_PARSE_EVENT = 'MarkupParse', OPEN_EVENT = 'Open', CHANGE_EVENT = 'Change', NS = 'mfp', EVENT_NS = '.'
      + NS, READY_CLASS = 'mfp-ready', REMOVING_CLASS = 'mfp-removing', PREVENT_CLOSE_CLASS = 'mfp-prevent-close';

  /**
   * Private vars
   */
  var mfp, // As we have only one instance of MagnificPopup object, we define
  // it locally to not to use 'this'
  MagnificPopup = function() {
  }, _isJQ = !!(window.jQuery), _prevStatus, _window = $(window), _body, _document, _prevContentType, _wrapClasses, _currPopupType;

  /**
   * Private functions
   */
  var _mfpOn = function(name, f) {
    mfp.ev.on(NS + name + EVENT_NS, f);
  }, _getEl = function(className, appendTo, html, raw) {
    var el = document.createElement('div');
    el.className = 'mfp-' + className;
    if (html) {
      el.innerHTML = html;
    }
    if (!raw) {
      el = $(el);
      if (appendTo) {
        el.appendTo(appendTo);
      }
    } else if (appendTo) {
      appendTo.appendChild(el);
    }
    return el;
  }, _mfpTrigger = function(e, data) {
    mfp.ev.triggerHandler(NS + e, data);

    if (mfp.st.callbacks) {
      // converts "mfpEventName" to "eventName" callback and triggers it if it's
      // present
      e = e.charAt(0).toLowerCase() + e.slice(1);
      if (mfp.st.callbacks[e]) {
        mfp.st.callbacks[e].apply(mfp, $.isArray(data) ? data : [ data ]);
      }
    }
  }, _getCloseBtn = function(type) {
    if (type !== _currPopupType || !mfp.currTemplate.closeBtn) {
      mfp.currTemplate.closeBtn = $(mfp.st.closeMarkup.replace('%title%',
          mfp.st.tClose));
      _currPopupType = type;
    }
    return mfp.currTemplate.closeBtn;
  },
  // Initialize Magnific Popup only when called at least once
  _checkInstance = function() {
    if (!$.magnificPopup.instance) {
      mfp = new MagnificPopup();
      mfp.init();
      $.magnificPopup.instance = mfp;
    }
  },
  // CSS transition detection,
  // http://stackoverflow.com/questions/7264899/detect-css-transitions-using-javascript-and-without-modernizr
  supportsTransitions = function() {
    var s = document.createElement('p').style, // 's' for style. better to
    // create an element if body yet
    // to exist
    v = [ 'ms', 'O', 'Moz', 'Webkit' ]; // 'v' for vendor

    if (s['transition'] !== undefined) {
      return true;
    }

    while (v.length) {
      if (v.pop() + 'Transition' in s) {
        return true;
      }
    }

    return false;
  }, canPrevious = function() {
    return mfp.index > 0 || mfp.st.nxHasPreviousPage === true;
  }, canNext = function() {
    return mfp.index < (mfp.items.length - 1) || mfp.st.nxHasNextPage === true;
  };

  /**
   * Public functions
   */
  MagnificPopup.prototype = {

    constructor : MagnificPopup,

    /**
     * Initializes Magnific Popup plugin. This function is triggered only once
     * when $.fn.magnificPopup or $.magnificPopup is executed
     */
    init : function() {
      var appVersion = navigator.appVersion;
      mfp.isIE7 = appVersion.indexOf("MSIE 7.") !== -1;
      mfp.isIE8 = appVersion.indexOf("MSIE 8.") !== -1;
      mfp.isLowIE = mfp.isIE7 || mfp.isIE8;
      mfp.isAndroid = (/android/gi).test(appVersion);
      mfp.isIOS = (/iphone|ipad|ipod/gi).test(appVersion);
      mfp.supportsTransition = supportsTransitions();

      // We disable fixed positioned lightbox on devices that don't handle it
      // nicely.
      // If you know a better way of detecting this - let me know.
      mfp.probablyMobile = (mfp.isAndroid || mfp.isIOS || /(Opera Mini)|Kindle|webOS|BlackBerry|(Opera Mobi)|(Windows Phone)|IEMobile/i
          .test(navigator.userAgent));
      _document = $(document);

      mfp.popupsCache = {};
    },

    /**
     * Opens popup
     *
     * @param data
     *          [description]
     */
    open : function(data) {

      if (!_body) {
        _body = $(document.body);
      }

      var i;

      if (data.isObj === false) {
        // convert jQuery collection to array to avoid conflicts later
        mfp.items = data.items.toArray();

        mfp.index = 0;
        var items = data.items, item;
        for (i = 0; i < items.length; i++) {
          item = items[i];
          if (item.parsed) {
            item = item.el[0];
          }
          if (item === data.el[0]) {
            mfp.index = i;
            break;
          }
        }
      } else {
        mfp.items = $.isArray(data.items) ? data.items : [ data.items ];
        mfp.index = data.index || 0;
      }

      // if popup is already opened - we just update the content
      if (mfp.isOpen) {
        mfp.updateItemHTML();
        return;
      }

      mfp.types = [];
      _wrapClasses = '';
      if (data.mainEl && data.mainEl.length) {
        mfp.ev = data.mainEl.eq(0);
      } else {
        mfp.ev = _document;
      }

      if (data.key) {
        if (!mfp.popupsCache[data.key]) {
          mfp.popupsCache[data.key] = {};
        }
        mfp.currTemplate = mfp.popupsCache[data.key];
      } else {
        mfp.currTemplate = {};
      }

      mfp.st = $.extend(true, {}, $.magnificPopup.defaults, data);
      mfp.fixedContentPos = mfp.st.fixedContentPos === 'auto' ? !mfp.probablyMobile
          : mfp.st.fixedContentPos;

      if (mfp.st.modal) {
        mfp.st.closeOnContentClick = false;
        mfp.st.closeOnBgClick = false;
        mfp.st.showCloseBtn = false;
        mfp.st.enableEscapeKey = false;
      }

      // Building markup
      // main containers are created only once
      if (!mfp.bgOverlay) {

        // Dark overlay
        mfp.bgOverlay = _getEl('bg').on('click' + EVENT_NS, function() {
          mfp.close();
        });

        mfp.wrap = _getEl('wrap').attr('tabindex', -1).on('click' + EVENT_NS,
            function(e) {
              if (mfp._checkIfClose(e.target)) {
                mfp.close();
              }
            });

        mfp.container = _getEl('container', mfp.wrap);
      }

      mfp.contentContainer = _getEl('content');
      if (mfp.st.preloader) {
        mfp.preloader = _getEl('preloader', mfp.container, mfp.st.tLoading);
      }

      // Initializing modules
      var modules = $.magnificPopup.modules;
      for (i = 0; i < modules.length; i++) {
        var n = modules[i];
        n = n.charAt(0).toUpperCase() + n.slice(1);
        mfp['init' + n].call(mfp);
      }
      _mfpTrigger('BeforeOpen');

      if (mfp.st.showCloseBtn) {
        // Close button
        if (!mfp.st.closeBtnInside) {
          mfp.wrap.append(_getCloseBtn());
        } else {
          _mfpOn(MARKUP_PARSE_EVENT, function(e, template, values, item) {
            values.close_replaceWith = _getCloseBtn(item.type);
          });
          _wrapClasses += ' mfp-close-btn-in';
        }
      }

      if (mfp.st.alignTop) {
        _wrapClasses += ' mfp-align-top';
      }

      if (mfp.fixedContentPos) {
        mfp.wrap.css({
          overflow : mfp.st.overflowY,
          overflowX : 'hidden',
          overflowY : mfp.st.overflowY
        });
      } else {
        mfp.wrap.css({
          top : _window.scrollTop(),
          position : 'absolute'
        });
      }
      if (mfp.st.fixedBgPos === false
          || (mfp.st.fixedBgPos === 'auto' && !mfp.fixedContentPos)) {
        mfp.bgOverlay.css({
          height : _document.height(),
          position : 'absolute'
        });
      }

      if (mfp.st.enableEscapeKey) {
        // Close on ESC key
        _document.on('keyup' + EVENT_NS, function(e) {
          if (e.keyCode === 27) {
            mfp.close();
          }
        });
      }

      _window.on('resize' + EVENT_NS, function() {
        mfp.updateSize();
      });

      if (!mfp.st.closeOnContentClick) {
        _wrapClasses += ' mfp-auto-cursor';
      }

      if (_wrapClasses)
        mfp.wrap.addClass(_wrapClasses);

      // this triggers recalculation of layout, so we get it once to not to
      // trigger twice
      var windowHeight = mfp.wH = _window.height();

      var windowStyles = {};

      if (mfp.fixedContentPos) {
        if (mfp._hasScrollBar(windowHeight)) {
          var s = mfp._getScrollbarSize();
          if (s) {
            windowStyles.marginRight = s;
          }
        }
      }

      if (mfp.fixedContentPos) {
        if (!mfp.isIE7) {
          windowStyles.overflow = 'hidden';
        } else {
          // ie7 double-scroll bug
          $('body, html').css('overflow', 'hidden');
        }
      }

      var classesToadd = mfp.st.mainClass;
      if (mfp.isIE7) {
        classesToadd += ' mfp-ie7';
      }
      if (classesToadd) {
        mfp._addClassToMFP(classesToadd);
      }

      // add content
      mfp.updateItemHTML();

      _mfpTrigger('BuildControls');

      // remove scrollbar, add margin e.t.c
      $('html').css(windowStyles);

      // add everything to DOM
      mfp.bgOverlay.add(mfp.wrap).prependTo(mfp.st.prependTo || _body);

      // Save last focused element
      mfp._lastFocusedEl = document.activeElement;

      // Wait for next cycle to allow CSS transition
      setTimeout(function() {

        if (mfp.content) {
          mfp._addClassToMFP(READY_CLASS);
          mfp._setFocus();
        } else {
          // if content is not defined (not loaded e.t.c) we add class only for
          // BG
          mfp.bgOverlay.addClass(READY_CLASS);
        }

        // Trap the focus in popup
        _document.on('focusin' + EVENT_NS, mfp._onFocusIn);

      }, 16);

      mfp.isOpen = true;
      mfp.updateSize(windowHeight);
      _mfpTrigger(OPEN_EVENT);

      return data;
    },

    /**
     * Closes the popup
     */
    close : function() {
      if (!mfp.isOpen)
        return;
      _mfpTrigger(BEFORE_CLOSE_EVENT);

      mfp.isOpen = false;
      // for CSS3 animation
      if (mfp.st.removalDelay && !mfp.isLowIE && mfp.supportsTransition) {
        mfp._addClassToMFP(REMOVING_CLASS);
        setTimeout(function() {
          mfp._close();
        }, mfp.st.removalDelay);
      } else {
        mfp._close();
      }
    },

    /**
     * Helper for close() function
     */
    _close : function() {
      _mfpTrigger(CLOSE_EVENT);

      var classesToRemove = REMOVING_CLASS + ' ' + READY_CLASS + ' ';

      mfp.bgOverlay.detach();
      mfp.wrap.detach();
      mfp.container.empty();

      if (mfp.st.mainClass) {
        classesToRemove += mfp.st.mainClass + ' ';
      }

      mfp._removeClassFromMFP(classesToRemove);

      if (mfp.fixedContentPos) {
        var windowStyles = {
          marginRight : ''
        };
        if (mfp.isIE7) {
          $('body, html').css('overflow', '');
        } else {
          windowStyles.overflow = '';
        }
        $('html').css(windowStyles);
      }

      _document.off('keyup' + EVENT_NS + ' focusin' + EVENT_NS);
      mfp.ev.off(EVENT_NS);

      // clean up DOM elements that aren't removed
      mfp.wrap.attr('class', 'mfp-wrap').removeAttr('style');
      mfp.bgOverlay.attr('class', 'mfp-bg');
      mfp.container.attr('class', 'mfp-container');

      // remove close button from target element
      if (mfp.st.showCloseBtn
          && (!mfp.st.closeBtnInside || mfp.currTemplate[mfp.currItem.type] === true)) {
        if (mfp.currTemplate.closeBtn)
          mfp.currTemplate.closeBtn.detach();
      }

      if (mfp._lastFocusedEl) {
        $(mfp._lastFocusedEl).focus(); // put tab focus back
      }
      mfp.currItem = null;
      mfp.content = null;
      mfp.currTemplate = null;
      mfp.prevHeight = 0;

      _mfpTrigger(AFTER_CLOSE_EVENT);
    },

    updateSize : function(winHeight) {

      if (mfp.isIOS) {
        // fixes iOS nav bars
        // https://github.com/dimsemenov/Magnific-Popup/issues/2
        var zoomLevel = document.documentElement.clientWidth / window.innerWidth;
        var height = window.innerHeight * zoomLevel;
        mfp.wrap.css('height', height);
        mfp.wH = height;
      } else {
        mfp.wH = winHeight || _window.height();
      }
      // Fixes #84: popup incorrectly positioned with position:relative on body
      if (!mfp.fixedContentPos) {
        mfp.wrap.css('height', mfp.wH);
      }

      _mfpTrigger('Resize');

    },

    /**
     * Set content of popup based on current index
     */
    updateItemHTML : function() {
      var item = mfp.items[mfp.index];

      // Detach and perform modifications
      mfp.contentContainer.detach();

      if (mfp.content)
        mfp.content.detach();

      if (!item.parsed) {
        item = mfp.parseEl(mfp.index);
      }

      var type = item.type;

      _mfpTrigger('BeforeChange',
          [ mfp.currItem ? mfp.currItem.type : '', type ]);
      // BeforeChange event works like so:
      // _mfpOn('BeforeChange', function(e, prevType, newType) { });

      mfp.currItem = item;

      if (!mfp.currTemplate[type]) {
        var markup = mfp.st[type] ? mfp.st[type].markup : false;

        // allows to modify markup
        _mfpTrigger('FirstMarkupParse', markup);

        if (markup) {
          mfp.currTemplate[type] = $(markup);
        } else {
          // if there is no markup found we just define that template is parsed
          mfp.currTemplate[type] = true;
        }
      }

      if (_prevContentType && _prevContentType !== item.type) {
        mfp.container.removeClass('mfp-' + _prevContentType + '-holder');
      }

      var newContent = mfp['get' + type.charAt(0).toUpperCase() + type.slice(1)]
          (item, mfp.currTemplate[type]);
      mfp.appendContent(newContent, type);

      item.preloaded = true;

      _mfpTrigger(CHANGE_EVENT, item);
      _prevContentType = item.type;

      // Append container back after its content changed
      mfp.container.prepend(mfp.contentContainer);

      _mfpTrigger('AfterChange');
    },

    /**
     * Set HTML content of popup
     */
    appendContent : function(newContent, type) {
      mfp.content = newContent;

      if (newContent) {
        if (mfp.st.showCloseBtn && mfp.st.closeBtnInside
            && mfp.currTemplate[type] === true) {
          // if there is no markup, we just append close button element inside
          if (!mfp.content.find('.mfp-close').length) {
            mfp.content.append(_getCloseBtn());
          }
        } else {
          mfp.content = newContent;
        }
      } else {
        mfp.content = '';
      }

      _mfpTrigger(BEFORE_APPEND_EVENT);
      mfp.container.addClass('mfp-' + type + '-holder');

      mfp.contentContainer.append(mfp.content);
    },

    /**
     * Creates Magnific Popup data object based on given data
     *
     * @param {int}
     *          index Index of item to parse
     */
    parseEl : function(index) {
      var item = mfp.items[index], type;

      if (item.tagName) {
        item = {
          el : $(item)
        };
      } else {
        type = item.type;
        item = {
          data : item,
          src : item.src
        };
      }

      if (item.el) {
        var types = mfp.types;

        // check for 'mfp-TYPE' class
        for ( var i = 0; i < types.length; i++) {
          if (item.el.hasClass('mfp-' + types[i])) {
            type = types[i];
            break;
          }
        }

        item.src = item.el.attr('data-mfp-src');
        if (!item.src) {
          item.src = item.el.attr('href');
        }
      }

      item.type = type || mfp.st.type || 'inline';
      item.index = index;
      item.parsed = true;
      mfp.items[index] = item;
      _mfpTrigger('ElementParse', item);

      return mfp.items[index];
    },

    /**
     * Initializes single popup or a group of popups
     */
    addGroup : function(el, options) {
      var eHandler = function(e) {
        e.mfpEl = this;
        mfp._openClick(e, el, options);
      };

      if (!options) {
        options = {};
      }

      var eName = 'click.magnificPopup';
      options.mainEl = el;

      if (options.items) {
        options.isObj = true;
        el.off(eName).on(eName, eHandler);
      } else {
        options.isObj = false;
        if (options.delegate) {
          el.off(eName).on(eName, options.delegate, eHandler);
        } else {
          options.items = el;
          el.off(eName).on(eName, eHandler);
        }
      }
    },
    _openClick : function(e, el, options) {
      var midClick = options.midClick !== undefined ? options.midClick
          : $.magnificPopup.defaults.midClick;

      if (!midClick && (e.which === 2 || e.ctrlKey || e.metaKey)) {
        return;
      }

      var disableOn = options.disableOn !== undefined ? options.disableOn
          : $.magnificPopup.defaults.disableOn;

      if (disableOn) {
        if ($.isFunction(disableOn)) {
          if (!disableOn.call(mfp)) {
            return true;
          }
        } else { // else it's number
          if (_window.width() < disableOn) {
            return true;
          }
        }
      }

      if (e.type) {
        e.preventDefault();

        // This will prevent popup from closing if element is inside and popup
        // is already opened
        if (mfp.isOpen) {
          e.stopPropagation();
        }
      }

      options.el = $(e.mfpEl);
      if (options.delegate) {
        options.items = el.find(options.delegate);
      }
      mfp.open(options);
    },

    /**
     * Updates text on preloader
     */
    updateStatus : function(status, text) {

      if (mfp.preloader) {
        if (_prevStatus !== status) {
          mfp.container.removeClass('mfp-s-' + _prevStatus);
        }

        if (!text && status === 'loading') {
          text = mfp.st.tLoading;
        }

        var data = {
          status : status,
          text : text
        };
        // allows to modify status
        _mfpTrigger('UpdateStatus', data);

        status = data.status;
        text = data.text;

        mfp.preloader.html(text);

        mfp.preloader.find('a').on('click', function(e) {
          e.stopImmediatePropagation();
        });

        mfp.container.addClass('mfp-s-' + status);
        _prevStatus = status;
      }
    },

    /*
     * "Private" helpers that aren't private at all
     */
    // Check to close popup or not
    // "target" is an element that was clicked
    _checkIfClose : function(target) {

      if ($(target).hasClass(PREVENT_CLOSE_CLASS)) {
        return;
      }

      var closeOnContent = mfp.st.closeOnContentClick;
      var closeOnBg = mfp.st.closeOnBgClick;

      if (closeOnContent && closeOnBg) {
        return true;
      } else {

        // We close the popup if click is on close button or on preloader. Or if
        // there is no content.
        if (!mfp.content || $(target).hasClass('mfp-close')
            || (mfp.preloader && target === mfp.preloader[0])) {
          return true;
        }

        // if click is outside the content
        if ((target !== mfp.content[0] && !$.contains(mfp.content[0], target))) {
          if (closeOnBg) {
            // last check, if the clicked element is in DOM, (in case it's
            // removed onclick)
            if ($.contains(document, target)) {
              return true;
            }
          }
        } else if (closeOnContent) {
          return true;
        }

      }
      return false;
    },
    _addClassToMFP : function(cName) {
      mfp.bgOverlay.addClass(cName);
      mfp.wrap.addClass(cName);
    },
    _removeClassFromMFP : function(cName) {
      this.bgOverlay.removeClass(cName);
      mfp.wrap.removeClass(cName);
    },
    _hasScrollBar : function(winHeight) {
      return ((mfp.isIE7 ? _document.height() : document.body.scrollHeight) > (winHeight || _window
          .height()));
    },
    _setFocus : function() {
      (mfp.st.focus ? mfp.content.find(mfp.st.focus).eq(0) : mfp.wrap).focus();
    },
    _onFocusIn : function(e) {
      if (e.target !== mfp.wrap[0] && !$.contains(mfp.wrap[0], e.target)) {
        mfp._setFocus();
        return false;
      }
    },
    _parseMarkup : function(template, values, item) {
      var arr;
      if (item.data) {
        values = $.extend(item.data, values);
      }
      _mfpTrigger(MARKUP_PARSE_EVENT, [ template, values, item ]);

      $.each(values, function(key, value) {
        if (value === undefined || value === false) {
          return true;
        }
        arr = key.split('_');
        if (arr.length > 1) {
          var el = template.find(EVENT_NS + '-' + arr[0]);

          if (el.length > 0) {
            var attr = arr[1];
            if (attr === 'replaceWith') {
              if (el[0] !== value[0]) {
                el.replaceWith(value);
              }
            } else if (attr === 'img') {
              if (el.is('img')) {
                el.attr('src', value);
              } else {
                el.replaceWith('<img src="' + value + '" class="'
                    + el.attr('class') + '" />');
              }
            } else {
              el.attr(arr[1], value);
            }
          }

        } else {
          template.find(EVENT_NS + '-' + key).html(value);
        }
      });
    },

    _getScrollbarSize : function() {
      // thx David
      if (mfp.scrollbarSize === undefined) {
        var scrollDiv = document.createElement("div");
        scrollDiv.id = "mfp-sbm";
        scrollDiv.style.cssText = 'width: 99px; height: 99px; overflow: scroll; position: absolute; top: -9999px;';
        document.body.appendChild(scrollDiv);
        mfp.scrollbarSize = scrollDiv.offsetWidth - scrollDiv.clientWidth;
        document.body.removeChild(scrollDiv);
      }
      return mfp.scrollbarSize;
    }

  }; /* MagnificPopup core prototype end */

  /**
   * Public static functions
   */
  $.magnificPopup = {
    instance : null,
    proto : MagnificPopup.prototype,
    modules : [],

    open : function(options, index) {
      _checkInstance();

      if (!options) {
        options = {};
      } else {
        options = $.extend(true, {}, options);
      }

      options.isObj = true;
      options.index = index || 0;
      return this.instance.open(options);
    },

    close : function() {
      return $.magnificPopup.instance && $.magnificPopup.instance.close();
    },

    registerModule : function(name, module) {
      if (module.options) {
        $.magnificPopup.defaults[name] = module.options;
      }
      $.extend(this.proto, module.proto);
      this.modules.push(name);
    },

    defaults : {

      // Info about options is in docs:
      // http://dimsemenov.com/plugins/magnific-popup/documentation.html#options

      disableOn : 0,

      key : null,

      midClick : false,

      mainClass : '',

      preloader : true,

      focus : '', // CSS selector of input to focus after popup is opened

      closeOnContentClick : false,

      closeOnBgClick : true,

      closeBtnInside : true,

      showCloseBtn : true,

      enableEscapeKey : true,

      modal : false,

      alignTop : false,

      removalDelay : 0,

      prependTo : null,

      fixedContentPos : 'auto',

      fixedBgPos : 'auto',

      overflowY : 'auto',

      closeMarkup : '<button title="%title%" type="button" class="mfp-close">&times;</button>',

      tClose : 'Close (Esc)',

      tLoading : 'Loading...'

    }
  };

  $.fn.magnificPopup = function(options) {
    _checkInstance();

    var jqEl = $(this);

    // We call some API method of first param is a string
    if (typeof options === "string") {

      if (options === 'open') {
        var items, itemOpts = _isJQ ? jqEl.data('magnificPopup')
            : jqEl[0].magnificPopup, index = parseInt(arguments[1], 10) || 0;

        if (itemOpts.items) {
          items = itemOpts.items[index];
        } else {
          items = jqEl;
          if (itemOpts.delegate) {
            items = items.find(itemOpts.delegate);
          }
          items = items.eq(index);
        }
        mfp._openClick({
          mfpEl : items
        }, jqEl, itemOpts);
      } else {
        if (mfp.isOpen)
          mfp[options].apply(mfp, Array.prototype.slice.call(arguments, 1));
      }

    } else {
      // clone options obj
      options = $.extend(true, {}, options);

      /*
       * As Zepto doesn't support .data() method for objects and it works only
       * in normal browsers we assign "options" object directly to the DOM
       * element. FTW!
       */
      if (_isJQ) {
        jqEl.data('magnificPopup', options);
      } else {
        jqEl[0].magnificPopup = options;
      }

      mfp.addGroup(jqEl, options);

    }
    return jqEl;
  };

  // Quick benchmark
  /*
   * var start = performance.now(), i, rounds = 1000;
   *
   * for(i = 0; i < rounds; i++) {
   *  } console.log('Test #1:', performance.now() - start);
   *
   * start = performance.now(); for(i = 0; i < rounds; i++) {
   *  } console.log('Test #2:', performance.now() - start);
   */

  /* >>core */

  /* >>inline */

  var INLINE_NS = 'inline', _hiddenClass, _inlinePlaceholder, _lastInlineElement, _putInlineElementsBack = function() {
    if (_lastInlineElement) {
      _inlinePlaceholder.after(_lastInlineElement.addClass(_hiddenClass))
          .detach();
      _lastInlineElement = null;
    }
  };

  $.magnificPopup.registerModule(INLINE_NS, {
    options : {
      hiddenClass : 'hide', // will be appended with `mfp-` prefix
      markup : '',
      tNotFound : 'Content not found'
    },
    proto : {

      initInline : function() {
        mfp.types.push(INLINE_NS);

        _mfpOn(CLOSE_EVENT + '.' + INLINE_NS, function() {
          _putInlineElementsBack();
        });
      },

      getInline : function(item, template) {

        _putInlineElementsBack();

        if (item.src) {
          var inlineSt = mfp.st.inline, el = $(item.src);

          if (el.length) {

            // If target element has parent - we replace it with placeholder and
            // put it back after popup is closed
            var parent = el[0].parentNode;
            if (parent && parent.tagName) {
              if (!_inlinePlaceholder) {
                _hiddenClass = inlineSt.hiddenClass;
                _inlinePlaceholder = _getEl(_hiddenClass);
                _hiddenClass = 'mfp-' + _hiddenClass;
              }
              // replace target inline element with placeholder
              _lastInlineElement = el.after(_inlinePlaceholder).detach()
                  .removeClass(_hiddenClass);
            }

            mfp.updateStatus('ready');
          } else {
            mfp.updateStatus('error', inlineSt.tNotFound);
            el = $('<div>');
          }

          item.inlineElement = el;
          return el;
        }

        mfp.updateStatus('ready');
        mfp._parseMarkup(template, {}, item);
        return template;
      }
    }
  });

  /* >>inline */

  /* >>ajax */
  var AJAX_NS = 'ajax', _ajaxCur, _removeAjaxCursor = function() {
    if (_ajaxCur) {
      _body.removeClass(_ajaxCur);
    }
  }, _destroyAjaxRequest = function() {
    _removeAjaxCursor();
    if (mfp.req) {
      mfp.req.abort();
    }
  };

  $.magnificPopup.registerModule(AJAX_NS, {

    options : {
      settings : null,
      cursor : 'mfp-ajax-cur',
      tError : '<a href="%url%">The content</a> could not be loaded.'
    },

    proto : {
      initAjax : function() {
        mfp.types.push(AJAX_NS);
        _ajaxCur = mfp.st.ajax.cursor;

        _mfpOn(CLOSE_EVENT + '.' + AJAX_NS, _destroyAjaxRequest);
        _mfpOn('BeforeChange.' + AJAX_NS, _destroyAjaxRequest);
      },
      getAjax : function(item) {

        if (_ajaxCur)
          _body.addClass(_ajaxCur);

        mfp.updateStatus('loading');

        var opts = $.extend({
          url : item.src,
          success : function(data, textStatus, jqXHR) {
            var temp = {
              data : data,
              xhr : jqXHR
            };

            _mfpTrigger('ParseAjax', temp);

            mfp.appendContent($(temp.data), AJAX_NS);

            item.finished = true;

            _removeAjaxCursor();

            mfp._setFocus();

            setTimeout(function() {
              mfp.wrap.addClass(READY_CLASS);
            }, 16);

            mfp.updateStatus('ready');

            _mfpTrigger('AjaxContentAdded');
          },
          error : function() {
            _removeAjaxCursor();
            item.finished = item.loadError = true;
            mfp.updateStatus('error', mfp.st.ajax.tError.replace('%url%',
                item.src));
          }
        }, mfp.st.ajax.settings);

        mfp.req = $.ajax(opts);

        return '';
      }
    }
  });

  /* >>ajax */

  /* >>image */
  var _imgInterval, _getTitle = function(item) {
    if (item.data && item.data.title !== undefined)
      return item.data.title;

    var src = mfp.st.image.titleSrc;

    if (src) {
      if ($.isFunction(src)) {
        return src.call(mfp, item);
      } else if (item.el) {
        return item.el.attr(src) || '';
      }
    }
    return '';
  };

  $.magnificPopup.registerModule('image', {

    options : {
      markup : '<div class="mfp-figure">' + '<div class="mfp-close"></div>'
          + '<figure>' + '<div class="mfp-img"></div>' + '<figcaption>'
          + '<div class="mfp-bottom-bar">' + '<div class="mfp-title"></div>'
          + '<div class="mfp-counter"></div>' + '</div>' + '</figcaption>'
          + '</figure>' + '</div>',
      cursor : 'mfp-zoom-out-cur',
      titleSrc : 'title',
      verticalFit : true,
      tError : '<a href="%url%">The image</a> could not be loaded.'
    },

    proto : {
      initImage : function() {
        var imgSt = mfp.st.image, ns = '.image';

        mfp.types.push('image');

        _mfpOn(OPEN_EVENT + ns, function() {
          if (mfp.currItem.type === 'image' && imgSt.cursor) {
            _body.addClass(imgSt.cursor);
          }
        });

        _mfpOn(CLOSE_EVENT + ns, function() {
          if (imgSt.cursor) {
            _body.removeClass(imgSt.cursor);
          }
          _window.off('resize' + EVENT_NS);
        });

        _mfpOn('Resize' + ns, mfp.resizeImage);
        if (mfp.isLowIE) {
          _mfpOn('AfterChange', mfp.resizeImage);
        }
      },
      resizeImage : function() {
        var item = mfp.currItem;
        if (!item || !item.img)
          return;

        if (mfp.st.image.verticalFit) {
          var decr = 0;
          // fix box-sizing in ie7/8
          if (mfp.isLowIE) {
            decr = parseInt(item.img.css('padding-top'), 10)
                + parseInt(item.img.css('padding-bottom'), 10);
          }
          item.img.css('max-height', mfp.wH - decr);
        }
      },
      _onImageHasSize : function(item) {
        if (item.img) {

          item.hasSize = true;

          if (_imgInterval) {
            clearInterval(_imgInterval);
          }

          item.isCheckingImgSize = false;

          _mfpTrigger('ImageHasSize', item);

          if (item.imgHidden) {
            if (mfp.content)
              mfp.content.removeClass('mfp-loading');

            item.imgHidden = false;
          }

        }
      },

      /**
       * Function that loops until the image has size to display elements that
       * rely on it asap
       */
      findImageSize : function(item) {

        var counter = 0, img = item.img[0], mfpSetInterval = function(delay) {

          if (_imgInterval) {
            clearInterval(_imgInterval);
          }
          // decelerating interval that checks for size of an image
          _imgInterval = setInterval(function() {
            if (img.naturalWidth > 0) {
              mfp._onImageHasSize(item);
              return;
            }

            if (counter > 200) {
              clearInterval(_imgInterval);
            }

            counter++;
            if (counter === 3) {
              mfpSetInterval(10);
            } else if (counter === 40) {
              mfpSetInterval(50);
            } else if (counter === 100) {
              mfpSetInterval(500);
            }
          }, delay);
        };

        mfpSetInterval(1);
      },

      getImage : function(item, template) {

        var guard = 0,

        // image load complete handler
        onLoadComplete = function() {
          if (item) {
            if (item.img[0].complete) {
              item.img.off('.mfploader');

              if (item === mfp.currItem) {
                mfp._onImageHasSize(item);

                mfp.updateStatus('ready');
              }

              item.hasSize = true;
              item.loaded = true;

              _mfpTrigger('ImageLoadComplete');

            } else {
              // if image complete check fails 200 times (20 sec), we assume
              // that there was an error.
              guard++;
              if (guard < 200) {
                setTimeout(onLoadComplete, 100);
              } else {
                onLoadError();
              }
            }
          }
        },

        // image error handler
        onLoadError = function() {
          if (item) {
            item.img.off('.mfploader');
            if (item === mfp.currItem) {
              mfp._onImageHasSize(item);
              mfp
                  .updateStatus('error', imgSt.tError
                      .replace('%url%', item.src));
            }

            item.hasSize = true;
            item.loaded = true;
            item.loadError = true;
          }
        }, imgSt = mfp.st.image;

        var el = template.find('.mfp-img');
        if (el.length) {
          var img = document.createElement('img');
          img.className = 'mfp-img';
          item.img = $(img).on('load.mfploader', onLoadComplete).on(
              'error.mfploader', onLoadError);
          img.src = item.src;

          // without clone() "error" event is not firing when IMG is replaced by
          // new IMG
          // TODO: find a way to avoid such cloning
          if (el.is('img')) {
            item.img = item.img.clone();
          }

          img = item.img[0];
          if (img.naturalWidth > 0) {
            item.hasSize = true;
          } else if (!img.width) {
            item.hasSize = false;
          }
        }

        mfp._parseMarkup(template, {
          title : _getTitle(item),
          img_replaceWith : item.img
        }, item);

        mfp.resizeImage();

        if (item.hasSize) {
          if (_imgInterval)
            clearInterval(_imgInterval);

          if (item.loadError) {
            template.addClass('mfp-loading');
            mfp.updateStatus('error', imgSt.tError.replace('%url%', item.src));
          } else {
            template.removeClass('mfp-loading');
            mfp.updateStatus('ready');
          }
          return template;
        }

        mfp.updateStatus('loading');
        item.loading = true;

        if (!item.hasSize) {
          item.imgHidden = true;
          template.addClass('mfp-loading');
          mfp.findImageSize(item);
        }

        return template;
      }
    }
  });

  /* >>image */

  /* >>zoom */
  var hasMozTransform, getHasMozTransform = function() {
    if (hasMozTransform === undefined) {
      hasMozTransform = document.createElement('p').style.MozTransform !== undefined;
    }
    return hasMozTransform;
  };

  $.magnificPopup
      .registerModule(
          'zoom',
          {

            options : {
              enabled : false,
              easing : 'ease-in-out',
              duration : 300,
              opener : function(element) {
                return element.is('img') ? element : element.find('img');
              }
            },

            proto : {

              initZoom : function() {
                var zoomSt = mfp.st.zoom, ns = '.zoom', image;

                if (!zoomSt.enabled || !mfp.supportsTransition) {
                  return;
                }

                var duration = zoomSt.duration, getElToAnimate = function(image) {
                  var newImg = image.clone().removeAttr('style').removeAttr(
                      'class').addClass('mfp-animated-image'), transition = 'all '
                      + (zoomSt.duration / 1000) + 's ' + zoomSt.easing, cssObj = {
                    position : 'fixed',
                    zIndex : 9999,
                    left : 0,
                    top : 0,
                    '-webkit-backface-visibility' : 'hidden'
                  }, t = 'transition';

                  cssObj['-webkit-' + t] = cssObj['-moz-' + t] = cssObj['-o-'
                      + t] = cssObj[t] = transition;

                  newImg.css(cssObj);
                  return newImg;
                }, showMainContent = function() {
                  mfp.content.css('visibility', 'visible');
                }, openTimeout, animatedImg;

                _mfpOn('BuildControls' + ns, function() {
                  if (mfp._allowZoom()) {

                    clearTimeout(openTimeout);
                    mfp.content.css('visibility', 'hidden');

                    // Basically, all code below does is clones existing image,
                    // puts in on top of the current one and animated it

                    image = mfp._getItemToZoom();

                    if (!image) {
                      showMainContent();
                      return;
                    }

                    animatedImg = getElToAnimate(image);

                    animatedImg.css(mfp._getOffset());

                    mfp.wrap.append(animatedImg);

                    openTimeout = setTimeout(function() {
                      animatedImg.css(mfp._getOffset(true));
                      openTimeout = setTimeout(function() {

                        showMainContent();

                        setTimeout(function() {
                          animatedImg.remove();
                          image = animatedImg = null;
                          _mfpTrigger('ZoomAnimationEnded');
                        }, 16); // avoid blink when switching images

                      }, duration); // this timeout equals animation duration

                    }, 16); // by adding this timeout we avoid short glitch at
                    // the beginning of animation

                    // Lots of timeouts...
                  }
                });
                _mfpOn(BEFORE_CLOSE_EVENT + ns, function() {
                  if (mfp._allowZoom()) {

                    clearTimeout(openTimeout);

                    mfp.st.removalDelay = duration;

                    if (!image) {
                      image = mfp._getItemToZoom();
                      if (!image) {
                        return;
                      }
                      animatedImg = getElToAnimate(image);
                    }

                    animatedImg.css(mfp._getOffset(true));
                    mfp.wrap.append(animatedImg);
                    mfp.content.css('visibility', 'hidden');

                    setTimeout(function() {
                      animatedImg.css(mfp._getOffset());
                    }, 16);
                  }

                });

                _mfpOn(CLOSE_EVENT + ns, function() {
                  if (mfp._allowZoom()) {
                    showMainContent();
                    if (animatedImg) {
                      animatedImg.remove();
                    }
                    image = null;
                  }
                });
              },

              _allowZoom : function() {
                return mfp.currItem.type === 'image';
              },

              _getItemToZoom : function() {
                if (mfp.currItem.hasSize) {
                  return mfp.currItem.img;
                } else {
                  return false;
                }
              },

              // Get element postion relative to viewport
              _getOffset : function(isLarge) {
                var el;
                if (isLarge) {
                  el = mfp.currItem.img;
                } else {
                  el = mfp.st.zoom.opener(mfp.currItem.el || mfp.currItem);
                }

                var offset = el.offset();
                var paddingTop = parseInt(el.css('padding-top'), 10);
                var paddingBottom = parseInt(el.css('padding-bottom'), 10);
                offset.top -= ($(window).scrollTop() - paddingTop);

                /*
                 *
                 * Animating left + top + width/height looks glitchy in Firefox,
                 * but perfect in Chrome. And vice-versa.
                 *
                 */
                var obj = {
                  width : el.width(),
                  // fix Zepto height+padding issue
                  height : (_isJQ ? el.innerHeight() : el[0].offsetHeight)
                      - paddingBottom - paddingTop
                };

                // I hate to do this, but there is no another option
                if (getHasMozTransform()) {
                  obj['-moz-transform'] = obj['transform'] = 'translate('
                      + offset.left + 'px,' + offset.top + 'px)';
                } else {
                  obj.left = offset.left;
                  obj.top = offset.top;
                }
                return obj;
              }

            }
          });

  /* >>zoom */

  /* >>iframe */

  var IFRAME_NS = 'iframe', _emptyPage = '//about:blank',

  _fixIframeBugs = function(isShowing) {
    if (mfp.currTemplate[IFRAME_NS]) {
      var el = mfp.currTemplate[IFRAME_NS].find('iframe');
      if (el.length) {
        // reset src after the popup is closed to avoid "video keeps playing
        // after popup is closed" bug
        if (!isShowing) {
          el[0].src = _emptyPage;
        }

        // IE8 black screen bug fix
        if (mfp.isIE8) {
          el.css('display', isShowing ? 'block' : 'none');
        }
      }
    }
  };

  $.magnificPopup
      .registerModule(
          IFRAME_NS,
          {

            options : {
              markup : '<div class="mfp-iframe-scaler">'
                  + '<div class="mfp-close"></div>'
                  + '<iframe class="mfp-iframe" src="//about:blank" frameborder="0" allowfullscreen></iframe>'
                  + '</div>',

              srcAction : 'iframe_src',

              // we don't care and support only one default type of URL by
              // default
              patterns : {
                youtube : {
                  index : 'youtube.com',
                  id : 'v=',
                  src : '//www.youtube.com/embed/%id%?autoplay=1'
                },
                vimeo : {
                  index : 'vimeo.com/',
                  id : '/',
                  src : '//player.vimeo.com/video/%id%?autoplay=1'
                },
                gmaps : {
                  index : '//maps.google.',
                  src : '%id%&output=embed'
                }
              }
            },

            proto : {
              initIframe : function() {
                mfp.types.push(IFRAME_NS);

                _mfpOn('BeforeChange', function(e, prevType, newType) {
                  if (prevType !== newType) {
                    if (prevType === IFRAME_NS) {
                      _fixIframeBugs(); // iframe if removed
                    } else if (newType === IFRAME_NS) {
                      _fixIframeBugs(true); // iframe is showing
                    }
                  }// else {
                  // iframe source is switched, don't do anything
                  // }
                });

                _mfpOn(CLOSE_EVENT + '.' + IFRAME_NS, function() {
                  _fixIframeBugs();
                });
              },

              getIframe : function(item, template) {
                var embedSrc = item.src;
                var iframeSt = mfp.st.iframe;

                $.each(iframeSt.patterns, function() {
                  if (embedSrc.indexOf(this.index) > -1) {
                    if (this.id) {
                      if (typeof this.id === 'string') {
                        embedSrc = embedSrc.substr(embedSrc
                            .lastIndexOf(this.id)
                            + this.id.length, embedSrc.length);
                      } else {
                        embedSrc = this.id.call(this, embedSrc);
                      }
                    }
                    embedSrc = this.src.replace('%id%', embedSrc);
                    return false; // break;
                  }
                });

                var dataObj = {};
                if (iframeSt.srcAction) {
                  dataObj[iframeSt.srcAction] = embedSrc;
                }
                mfp._parseMarkup(template, dataObj, item);

                mfp.updateStatus('ready');

                return template;
              }
            }
          });

  /* >>iframe */

  /* >>gallery */
  /**
   * Get looped index depending on number of slides
   */
  var _getLoopedId = function(index) {
    var numSlides = mfp.items.length;
    if (index > numSlides - 1) {
      return index - numSlides;
    } else if (index < 0) {
      return numSlides + index;
    }
    return index;
  }, _replaceCurrTotal = function(text, curr, total) {
    return text.replace(/%curr%/gi, curr + 1).replace(/%total%/gi, total);
  };

  $.magnificPopup
      .registerModule(
          'gallery',
          {

            options : {
              enabled : false,
              arrowMarkup : '<button title="%title%" type="button" class="mfp-arrow mfp-arrow-%dir%"></button>',
              preload : [ 0, 2 ],
              navigateByImgClick : true,
              arrows : true,

              tPrev : 'Previous (Left arrow key)',
              tNext : 'Next (Right arrow key)',
              tCounter : '%curr% of %total%'
            },

            proto : {
              initGallery : function() {

                var gSt = mfp.st.gallery, ns = '.mfp-gallery', supportsFastClick = Boolean($.fn.mfpFastClick);

                mfp.direction = true; // true - next, false - prev

                if (!gSt || !gSt.enabled)
                  return false;

                _wrapClasses += ' mfp-gallery';

                _mfpOn(OPEN_EVENT + ns, function() {

                  if (gSt.navigateByImgClick) {
                    mfp.wrap.on('click' + ns, '.mfp-img', function() {
                      if (canNext()) {
                        mfp.next();
                        return false;
                      }
                    });
                  }

                  _document.on('keydown' + ns, function(e) {
                    if (e.keyCode === 37 && canPrevious()) {
                      mfp.prev();
                    } else if (e.keyCode === 39 && canNext()) {
                      mfp.next();
                    }
                  });
                });

                _mfpOn('UpdateStatus' + ns, function(e, data) {
                  if (data.text) {
                    data.text = _replaceCurrTotal(data.text,
                        mfp.currItem.index, mfp.items.length);
                  }
                });

                _mfpOn(MARKUP_PARSE_EVENT + ns, function(e, element, values,
                    item) {
                  var l = mfp.items.length;
                  values.counter = l > 1 ? _replaceCurrTotal(gSt.tCounter,
                      item.index, l) : '';
                });

                _mfpOn(
                    'BuildControls' + ns,
                    function() {
                      if (mfp.items.length > 1 && gSt.arrows) {
                        var markup = gSt.arrowMarkup, arrowLeft = mfp.arrowLeft = $(
                            markup.replace(/%title%/gi, gSt.tPrev).replace(
                                /%dir%/gi, 'left')).addClass(
                            PREVENT_CLOSE_CLASS), arrowRight = mfp.arrowRight = $(
                            markup.replace(/%title%/gi, gSt.tNext).replace(
                                /%dir%/gi, 'right')).addClass(
                            PREVENT_CLOSE_CLASS);

                        var eName = supportsFastClick ? 'mfpFastClick'
                            : 'click';
                        arrowLeft[eName](function() {
                          mfp.prev();
                        });
                        arrowRight[eName](function() {
                          mfp.next();
                        });

                        // Polyfill for :before and :after (adds elements with
                        // classes mfp-a and mfp-b)
                        if (mfp.isIE7) {
                          _getEl('b', arrowLeft[0], false, true);
                          _getEl('a', arrowLeft[0], false, true);
                          _getEl('b', arrowRight[0], false, true);
                          _getEl('a', arrowRight[0], false, true);
                        }

                        if (canNext()) {
                          if (!mfp.container.has('.mfp-arrow-right').length) {
                            mfp.container.append(arrowRight);
                          }
                        } else {
                          mfp.container.find('.mfp-arrow-right').remove();
                        }
                        if (canPrevious()) {
                          if (!mfp.container.has('.mfp-arrow-left').length) {
                            mfp.container.append(arrowLeft);
                          }
                        } else {
                          mfp.container.find('.mfp-arrow-left').remove();
                        }
                      }
                    });

                _mfpOn(CHANGE_EVENT + ns, function() {
                  if (mfp._preloadTimeout)
                    clearTimeout(mfp._preloadTimeout);

                  mfp._preloadTimeout = setTimeout(function() {
                    mfp.preloadNearbyImages();
                    mfp._preloadTimeout = null;
                  }, 16);
                });

                _mfpOn(CLOSE_EVENT + ns, function() {
                  _document.off(ns);
                  mfp.wrap.off('click' + ns);

                  if (mfp.arrowLeft && supportsFastClick) {
                    mfp.arrowLeft.add(mfp.arrowRight).destroyMfpFastClick();
                  }
                  mfp.arrowRight = mfp.arrowLeft = null;
                });

              },
              next : function() {
                if (mfp.st.endOfPageCallback) {
                  if (mfp.index == (mfp.items.length - 1)) {
                    mfp.st.endOfPageCallback.apply();
                    this.close();
                    return;
                  }
                }
                var updateControls = false;
                if (mfp.index == 0 || mfp.index == (mfp.items.length - 2)) {
                  updateControls = true;
                }
                mfp.direction = true;
                mfp.index = _getLoopedId(mfp.index + 1);
                mfp.updateItemHTML();
                if (updateControls) {
                  _mfpTrigger('BuildControls');
                }
              },
              prev : function() {
                if (mfp.st.startOfPageCallback) {
                  if (mfp.index == 0) {
                    mfp.st.startOfPageCallback.apply();
                    this.close();
                    return;
                  }
                }
                var updateControls = false;
                if (mfp.index == 1 || mfp.index == mfp.items.length - 1) {
                  updateControls = true;
                }
                mfp.direction = false;
                mfp.index = _getLoopedId(mfp.index - 1);
                mfp.updateItemHTML();
                if (updateControls) {
                  _mfpTrigger('BuildControls');
                }
              },
              goTo : function(newIndex) {
                mfp.direction = (newIndex >= mfp.index);
                mfp.index = newIndex;
                mfp.updateItemHTML();
              },
              preloadNearbyImages : function() {
                var p = mfp.st.gallery.preload, preloadBefore = Math.min(p[0],
                    mfp.items.length), preloadAfter = Math.min(p[1],
                    mfp.items.length), i;

                for (i = 1; i <= (mfp.direction ? preloadAfter : preloadBefore); i++) {
                  mfp._preloadItem(mfp.index + i);
                }
                for (i = 1; i <= (mfp.direction ? preloadBefore : preloadAfter); i++) {
                  mfp._preloadItem(mfp.index - i);
                }
              },
              _preloadItem : function(index) {
                index = _getLoopedId(index);

                if (mfp.items[index].preloaded) {
                  return;
                }

                var item = mfp.items[index];
                if (!item.parsed) {
                  item = mfp.parseEl(index);
                }

                _mfpTrigger('LazyLoad', item);

                if (item.type === 'image') {
                  item.img = $('<img class="mfp-img" />').on('load.mfploader',
                      function() {
                        item.hasSize = true;
                      }).on('error.mfploader', function() {
                    item.hasSize = true;
                    item.loadError = true;
                    _mfpTrigger('LazyLoadError', item);
                  }).attr('src', item.src);
                }

                item.preloaded = true;
              }
            }
          });

  /*
   Touch Support that might be implemented some day

   addSwipeGesture: function() {
   var startX,
   moved,
   multipleTouches;

   return;

   var namespace = '.mfp',
   addEventNames = function(pref, down, move, up, cancel) {
   mfp._tStart = pref + down + namespace;
   mfp._tMove = pref + move + namespace;
   mfp._tEnd = pref + up + namespace;
   mfp._tCancel = pref + cancel + namespace;
   };

   if(window.navigator.msPointerEnabled) {
   addEventNames('MSPointer', 'Down', 'Move', 'Up', 'Cancel');
   } else if('ontouchstart' in window) {
   addEventNames('touch', 'start', 'move', 'end', 'cancel');
   } else {
   return;
   }
   _window.on(mfp._tStart, function(e) {
   var oE = e.originalEvent;
   multipleTouches = moved = false;
   startX = oE.pageX || oE.changedTouches[0].pageX;
   }).on(mfp._tMove, function(e) {
   if(e.originalEvent.touches.length > 1) {
   multipleTouches = e.originalEvent.touches.length;
   } else {
   //e.preventDefault();
   moved = true;
   }
   }).on(mfp._tEnd + ' ' + mfp._tCancel, function(e) {
   if(moved && !multipleTouches) {
   var oE = e.originalEvent,
   diff = startX - (oE.pageX || oE.changedTouches[0].pageX);

   if(diff > 20) {
   mfp.next();
   } else if(diff < -20) {
   mfp.prev();
   }
   }
   });
   },
   */

  /*>>gallery*/

  /*>>retina*/

  var RETINA_NS = 'retina';

  $.magnificPopup.registerModule(RETINA_NS, {
    options : {
      replaceSrc : function(item) {
        return item.src.replace(/\.\w+$/, function(m) {
          return '@2x' + m;
        });
      },
      ratio : 1
    // Function or number.  Set to 1 to disable.
    },
    proto : {
      initRetina : function() {
        if (window.devicePixelRatio > 1) {

          var st = mfp.st.retina, ratio = st.ratio;

          ratio = !isNaN(ratio) ? ratio : ratio();

          if (ratio > 1) {
            _mfpOn('ImageHasSize' + '.' + RETINA_NS, function(e, item) {
              item.img.css({
                'max-width' : item.img[0].naturalWidth / ratio,
                'width' : '100%'
              });
            });
            _mfpOn('ElementParse' + '.' + RETINA_NS, function(e, item) {
              item.src = st.replaceSrc(item, ratio);
            });
          }
        }

      }
    }
  });

  /*>>retina*/

  /*>>fastclick*/
  /**
   * FastClick event implementation. (removes 300ms delay on touch devices)
   * Based on https://developers.google.com/mobile/articles/fast_buttons
   *
   * You may use it outside the Magnific Popup by calling just:
   *
   * $('.your-el').mfpFastClick(function() {
   *     console.log('Clicked!');
   * });
   *
   * To unbind:
   * $('.your-el').destroyMfpFastClick();
   *
   *
   * Note that it's a very basic and simple implementation, it blocks ghost click on the same element where it was bound.
   * If you need something more advanced, use plugin by FT Labs https://github.com/ftlabs/fastclick
   *
   */

  (function() {
    var ghostClickDelay = 1000, supportsTouch = 'ontouchstart' in window, unbindTouchMove = function() {
      _window.off('touchmove' + ns + ' touchend' + ns);
    }, eName = 'mfpFastClick', ns = '.' + eName;

    // As Zepto.js doesn't have an easy way to add custom events (like jQuery), so we implement it in this way
    $.fn.mfpFastClick = function(callback) {

      return $(this).each(
          function() {

            var elem = $(this), lock;

            if (supportsTouch) {

              var timeout, startX, startY, pointerMoved, point, numPointers;

              elem.on('touchstart' + ns, function(e) {
                pointerMoved = false;
                numPointers = 1;

                point = e.originalEvent ? e.originalEvent.touches[0]
                    : e.touches[0];
                startX = point.clientX;
                startY = point.clientY;

                _window.on(
                    'touchmove' + ns,
                    function(e) {
                      point = e.originalEvent ? e.originalEvent.touches
                          : e.touches;
                      numPointers = point.length;
                      point = point[0];
                      if (Math.abs(point.clientX - startX) > 10
                          || Math.abs(point.clientY - startY) > 10) {
                        pointerMoved = true;
                        unbindTouchMove();
                      }
                    }).on('touchend' + ns, function(e) {
                  unbindTouchMove();
                  if (pointerMoved || numPointers > 1) {
                    return;
                  }
                  lock = true;
                  e.preventDefault();
                  clearTimeout(timeout);
                  timeout = setTimeout(function() {
                    lock = false;
                  }, ghostClickDelay);
                  callback();
                });
              });

            }

            elem.on('click' + ns, function() {
              if (!lock) {
                callback();
              }
            });
          });
    };

    $.fn.destroyMfpFastClick = function() {
      $(this).off('touchstart' + ns + ' click' + ns);
      if (supportsTouch)
        _window.off('touchmove' + ns + ' touchend' + ns);
    };
  })();

  /*>>fastclick*/
  _checkInstance();
})(window.jQuery || window.Zepto);
